const { Buffer } = require('buffer');
const net = require('net');
const fs = require('fs');
const path = require('path');
const os = require('os');
const { app } = require('electron');

class TcpConfigDownloader {
    constructor() {
        this.client = null;
        this.isConnected = false;
        this.isConnecting = false;
        this.host = '';
        this.port = 0;
        this.logCallback = null;
        this.onDataParsed = null;
        this.onDownloadComplete = null;
        // 添加数据缓冲区，用于处理分块传输的数据
        this.dataBuffer = Buffer.alloc(0);
        // 添加请求处理队列，用于存储待处理的请求及其回调
        this.requestQueue = [];
        // 当前正在处理的请求
        this.currentRequest = null;
        // 当前请求的数据包数量
        this.currentPacketCount = 0;
        // 控制是否应该重试处理缓冲区的标志
        this.shouldRetryProcessing = true;
    }

    // 连接到TCP服务器
    async connect(host, port) {
        return new Promise((resolve, reject) => {
            if (this.isConnected) {
                this._log('INFO', 'tcp已经连接到服务器，无需重新连接');
                resolve({ success: true, message: 'tcp已连接' });
                return;
            }
            if (this.isConnecting) {
                this._log('INFO', 'tcp正在连接中，请稍候...');
                resolve({ success: false, message: 'tcp正在连接中' });
                return;
            }
            this.isConnecting = true;
            this.host = host;
            this.port = port;
            this._log('INFO', `tcp开始连接服务器: ${host}:${port}`);
            try {
                this.client = net.createConnection(port, host);
                this.client.on('connect', () => {
                    this.isConnecting = false;
                    this.isConnected = true;
                    this._log('INFO', 'tcp连接成功');
                    resolve({ success: true, message: 'tcp连接成功' });
                });
                this.client.on('data', (data) => {                       
                    // 将新收到的数据追加到缓冲区
                    this.dataBuffer = Buffer.concat([this.dataBuffer, data]);                    
                    const hex = data.toString('hex').match(/.{1,2}/g).join(' ');
                    this._log('RECEIVE', `tcp接收到数据 (${data.length} 字节): ${hex}`);
                    // 打印数据长度和前16字节的十六进制表示，便于调试
                    const shortHex = data.slice(0, 16).toString('hex');
                    this._log('RECEIVE', `tcp接收到数据片段 (${data.length} 字节)，缓冲区总长度: ${this.dataBuffer.length}字节，数据片段前16字节: ${shortHex}`);
                    // 使用setImmediate确保数据处理不会阻塞事件循环
                    setImmediate(() => {
                        try {
                            this._processDataBuffer();
                        } catch (err) {
                            this._log('ERROR', `处理接收到的数据时出错: ${err.message}`);
                        }
                    });
                });                
                this.client.on('error', (err) => {
                    this.isConnecting = false;
                    this.isConnected = false;
                    this._log('ERROR', err.message);
                    reject({ success: false, message: err.message });
                });

                this.client.on('close', () => {
                    this.isConnected = false;
                    this.isConnecting = false;
                    this._log('INFO', '连接已关闭');
                });
            } catch (error) {
                this.isConnecting = false;
                this._log('ERROR', `连接异常: ${error.message}`);
                reject({ success: false, message: error.message });
            }
        });
    }
    // 处理数据缓冲区，等待完整数据接收后再解析
    _processDataBuffer() {
        try {
            // 设置处理限制，防止单次处理时间过长
            const MAX_PROCESS_ITERATIONS = 3; // 限制单次处理的数据包数量
            let processCount = 0;            
            this._log('DEBUG', `开始处理缓冲区数据，当前长度: ${this.dataBuffer.length}字节`);                        
            // 持续尝试从缓冲区中提取完整的数据包，但限制处理次数
            while (this.dataBuffer.length > 0 && processCount < MAX_PROCESS_ITERATIONS) {
                // 检查是否有正在处理的请求
                if (!this.currentRequest) {
                    if (this.requestQueue.length === 0) {
                        this._log('DEBUG', '没有待处理的请求，停止处理缓冲区');
                        break;
                    }
                    // 从队列中取出下一个请求
                    this.currentRequest = this.requestQueue.shift();
                    this.currentPacketCount = 0;
                    this._log('DEBUG', `开始处理新请求，当前队列剩余: ${this.requestQueue.length}个请求`);
                }                
                // 对于第一条数据，需要检测头部标志
                if (this.currentPacketCount === 0) {
                    // 至少需要76字节来解析头部
                    if (this.dataBuffer.length < 76) {
                        this._log('RECEIVE', `缓冲区数据不足，等待更多数据... 当前缓冲区长度: ${this.dataBuffer.length}字节`);
                        break; // 数据不足，等待下一次data事件
                    }                    
                    // 打印前16字节的原始数据，便于调试
                    const first16BytesHex = this.dataBuffer.slice(0, Math.min(16, this.dataBuffer.length)).toString('hex');
                    this._log('DEBUG', `当前缓冲区前${Math.min(16, this.dataBuffer.length)}字节原始数据: ${first16BytesHex}`);                    
                    // 直接截取前4字节进行比较
                    const headerBytes = this.dataBuffer.slice(0, 4);
                    const headerBytesHex = headerBytes.toString('hex');
                    const expectedHeaderHex = '40286bfe'; // 期望的头部标志，直接使用字符串比较                    
                    this._log('DEBUG', `当前缓冲区前4字节: 0x${headerBytesHex.toUpperCase()}`);                    
                    // 检查头部标志是否匹配
                    if (headerBytesHex !== expectedHeaderHex) {
                        this._log('ERROR', `头部标志不匹配，期望0x${expectedHeaderHex.toUpperCase()}，实际为0x${headerBytesHex.toUpperCase()}`);                        
                        // 直接拒绝当前请求并清除状态，不再继续尝试
                        if (this.currentRequest) {
                            const { reject } = this.currentRequest;
                            this.currentRequest = null;
                            this.currentPacketCount = 0;
                            reject({ success: false, message: '头部标志不匹配，数据解析失败' });
                        }                        
                        // 清除整个缓冲区的数据
                        this.dataBuffer = Buffer.alloc(0);
                        break; // 结束本次处理循环
                    }
                }                
                try {
                    // 使用小端序解析md5Flag和dataSize
                    const md5Flag = this.dataBuffer.readBigUInt64LE(52); // 偏移量52，8字节
                    let dataSize = this.dataBuffer.readBigUInt64LE(60); // 偏移量60，8字节                    
                    this._log('DEBUG', `使用小端序解析 - md5Flag: ${Number(md5Flag)}, dataSize: ${Number(dataSize)}字节`);                    
                    // 增加数据大小合理性检查
                    if (Number(dataSize) < 0 || Number(dataSize) > 10 * 1024 * 1024) { // 限制在0-10MB之间
                        this._log('ERROR', `数据大小无效(${Number(dataSize)}字节)，可能是解析错误`);
                        this.dataBuffer = this.dataBuffer.slice(4);                        
                        // 如果当前有请求，返回失败
                        if (this.currentRequest) {
                            const { reject } = this.currentRequest;
                            this.currentRequest = null;
                            this.currentPacketCount = 0;
                            reject({ success: false, message: '数据大小无效，解析失败' });
                        }
                        continue;
                    }                    
                    // 根据协议文档，更新总数据包大小
                    // dataSize表示命令附加信息长度，即MD5和传送文件总共占用字节数
                    // 头部长度固定为68字节（包含所有字段，包括可能未使用的md5Code字段）
                    const totalPacketSize = 68 + Number(dataSize); // 头部68字节 + 附加信息长度                    
                    // 检查totalPacketSize的合理性
                    // 优化示例：根据系统内存动态调整阈值
                    const memoryThreshold = Math.min(1024 * 1024, Math.floor(os.freemem() * 0.1)); // 最大1MB或可用内存的10%
                    if (totalPacketSize > this.dataBuffer.length + memoryThreshold) {
                        this._log('ERROR', `预计数据包过大(${totalPacketSize}字节)，可能是解析错误`);
                        this.dataBuffer = this.dataBuffer.slice(4);                        
                        // 如果当前有请求，返回失败
                        if (this.currentRequest) {
                            const { reject } = this.currentRequest;
                            this.currentRequest = null;
                            this.currentPacketCount = 0;
                            reject({ success: false, message: '预计数据包过大，解析失败' });
                        }
                        continue;
                    }
                    this._log('RECEIVE', `dataBuffer长度: ${this.dataBuffer.length}字节`);
                    this._log('RECEIVE', `totalPacketSize长度: ${totalPacketSize}字节`);
                    if (this.dataBuffer.length < totalPacketSize) {
                        // 数据不完整，等待更多数据
                        this._log('RECEIVE', `数据包不完整，等待更多数据... 当前缓冲区长度: ${this.dataBuffer.length}字节，需要: ${totalPacketSize}字节`);
                        // 不设置setImmediate重试，等待新的数据到达事件
                        this.shouldRetryProcessing = false;
                        break;
                    }                    
                    // 数据完整，可以处理
                    this._log('RECEIVE',`[数据解析] 发现完整数据包，开始解析，数据包总长度: ${totalPacketSize}字节，包序号: ${this.currentPacketCount + 1}`);                    
                    // 提取完整的数据包
                    const packetData = this.dataBuffer.slice(0, totalPacketSize);
                    // 从缓冲区中移除已处理的数据
                    this.dataBuffer = this.dataBuffer.slice(totalPacketSize);                    
                    // 增加处理计数
                    processCount++;
                    this.currentPacketCount++;                    
                    // 保存当前请求引用，防止在异步处理期间被修改
                    const currentRequest = this.currentRequest;                    
                    // 解析并处理完整的数据包
                    // 使用setImmediate确保不会阻塞事件循环
                    setImmediate(() => {
                        try {
                            this._parseAndProcessData(packetData, currentRequest);
                        } catch (err) {
                            this._log('ERROR', `异步处理数据包时出错: ${err.message}`);
                            if (currentRequest) {
                                const { reject } = currentRequest;
                                reject({ success: false, message: `处理数据包时出错: ${err.message}` });
                                // 清除当前请求
                                if (this.currentRequest === currentRequest) {
                                    this.currentRequest = null;
                                    this.currentPacketCount = 0;
                                }
                            }
                        }
                    });
                } catch (parseError) {
                    this._log('ERROR', `解析数据包头部时出错: ${parseError.message}`);
                    this.dataBuffer = this.dataBuffer.slice(1);
                    
                    // 如果当前有请求，返回失败
                    if (this.currentRequest) {
                        const { reject } = this.currentRequest;
                        this.currentRequest = null;
                        this.currentPacketCount = 0;
                        reject({ success: false, message: `解析数据包头部时出错: ${parseError.message}` });
                    }
                    continue;
                }
            }            
            // 如果还有未处理的数据且不是因为数据包不完整而退出的，则在下一个事件循环中继续处理
            if (this.dataBuffer.length > 0 && this.shouldRetryProcessing !== false) {
                setImmediate(() => {
                    try {
                        this._processDataBuffer();
                    } catch (err) {
                        this._log('ERROR', `继续处理缓冲区时出错: ${err.message}`);
                    }
                });
            }
            // 重置重试标志，允许下一次数据到达时正常处理
            this.shouldRetryProcessing = true;
        } catch (e) {
            this._log('ERROR', `数据缓冲区处理错误: ${e.message}`);
            // 保留部分缓冲区数据，避免完全清空导致数据丢失
            if (this.dataBuffer.length > 100) {
                this.dataBuffer = this.dataBuffer.slice(this.dataBuffer.length - 100);
                this._log('INFO', `发生错误，保留最后100字节数据继续尝试`);
            } else {
                this.dataBuffer = Buffer.alloc(0);
            }
        }
    }

    // 解析并处理完整的数据包
    async _parseAndProcessData(handlDataBuffer, currentRequest) {
        try {
            // 直接截取前4字节进行比较
            const headerBytes = handlDataBuffer.slice(0, 4);
            const headerBytesHex = headerBytes.toString('hex');
            const expectedHeaderHex = '40286bfe'; // 期望的头部标志，直接使用字符串比较

            this._log('RECEIVE',`[数据解析] 开始解析数据，数据总长度: ${handlDataBuffer.length}字节`);
            this._log('RECEIVE',`[数据解析] 头部标志: 0x${headerBytesHex.toUpperCase()}`);

            if (headerBytesHex === expectedHeaderHex) {
                // 修正字段偏移量
                const packType = handlDataBuffer.readUInt16LE(4);        // 偏移量4，2字节
                const sendType = handlDataBuffer.readUInt16LE(6);       // 偏移量6，2字节
                const sendNo = handlDataBuffer.readBigUInt64LE(8);      // 偏移量8，8字节 (Long类型)
                const recvType = handlDataBuffer.readUInt16LE(16);      // 偏移量16，2字节
                const recvNo = handlDataBuffer.readBigUInt64LE(18);     // 偏移量18，8字节 (Long类型)
                const cmdType = handlDataBuffer.readUInt16LE(26);       // 偏移量26，2字节
                const replyFlag = handlDataBuffer.readBigUInt64LE(28);  // 偏移量28，8字节 (Long类型)
                const taskID = handlDataBuffer.readBigUInt64LE(36);     // 偏移量36，8字节 (Long类型)
                const reserved3 = handlDataBuffer.readBigUInt64LE(44);  // 偏移量44，8字节 (Long类型)
                const md5Flag = handlDataBuffer.readBigUInt64LE(52);   // 偏移量52，8字节 (Long类型)
                const dataSize = handlDataBuffer.readBigUInt64LE(60);   // 偏移量60，8字节 (Long类型)
                
                // 根据协议文档，dataSize表示命令附加信息长度，即MD5和传送文件总共占用字节数
                // md5Flag=0表示没有md5Code，md5Flag=1表示有md5Code
                let md5Code = null;
                let fileDataOffset = 68; // 数据部分的起始偏移量，默认从68字节开始
                let fileData; // 声明fileData变量
                
                if (Number(md5Flag) === 1 && Number(dataSize) > 0) {
                    // 如果有md5Code，读取md5Code字段
                    md5Code = handlDataBuffer.readBigUInt64LE(68);   // 偏移量68，8字节 (Long类型)
                    // 数据部分从md5Code之后开始
                    fileDataOffset = 100; // md5Code占用32字节，所以数据部分从76字节开始
                    // dataSize包含了md5Code和文件数据，所以需要减去md5Code的长度
                    const fileDataSize = Number(dataSize) - 32; // 32字节是md5Code的长度
                    if (fileDataSize > 0) {
                        // 提取文件数据
                        fileData = handlDataBuffer.slice(fileDataOffset, fileDataOffset + fileDataSize);
                    } else {
                        // 如果fileDataSize不合法，仍然从68字节开始提取全部dataSize
                        fileData = handlDataBuffer.slice(68, 68 + Number(dataSize));
                    }
                } else {
                    // 如果没有md5Code，直接从68字节开始提取数据
                    fileData = handlDataBuffer.slice(68, 68 + Number(dataSize));
                }                
                this._log('RECEIVE', `[协议解析] md5Flag: ${Number(md5Flag)}, dataSize: ${Number(dataSize)}字节, fileDataOffset: ${fileDataOffset}字节`);
                //const fileDataStr = fileData.toString('utf8');
                this._log('RECEIVE',`[字段解析] packType: ${packType}`);
                this._log('RECEIVE',`[字段解析] sendType: ${sendType}`);
                this._log('RECEIVE',`[字段解析] sendNo: ${sendNo}`);
                this._log('RECEIVE',`[字段解析] recvType: ${recvType}`);
                this._log('RECEIVE',`[字段解析] recvNo: ${recvNo}`);
                this._log('RECEIVE',`[字段解析] cmdType: ${cmdType}`);
                this._log('RECEIVE',`[字段解析] replyFlag: ${replyFlag}`);
                this._log('RECEIVE',`[字段解析] taskID: ${taskID}`);
                this._log('RECEIVE',`[字段解析] reserved3: ${reserved3}`);
                this._log('RECEIVE',`[字段解析] md5Flag: ${md5Flag}`);
                this._log('RECEIVE',`[字段解析] dataSize: ${dataSize}`);
                this._log('RECEIVE',`[字段解析] md5Code: ${md5Code}`);
                //this._log('RECEIVE',`[字段解析] Data字段为：${fileData}，长度: ${fileData.length}字节`);
                try {
                    this._log('RECEIVE','[数据处理流程] 数据接收完成，开始处理...');
                    // 获取下载目录        
                    let saveFileName='task-'+taskID.toString()+'.xml';
                    if(cmdType === 4){//下载任务列表
                        saveFileName='tasklist.xml';
                    }
                    this._log('RECEIVE','file name:',saveFileName);
                    const taskDataDir = path.join(app.getPath('userData'), 'taskdata');
                    const savePath = path.join(taskDataDir, saveFileName);
                    this._log('RECEIVE',`[数据处理流程] 文件路径生成完成: ${savePath}`);
                    // 保存文件
                    this._log('RECEIVE','[数据处理流程] 开始保存文件');
                    // 异步处理文件保存，避免阻塞事件循环
                    try {
                        // 异步检查并创建taskdata文件夹
                        if (!fs.existsSync(taskDataDir)) {
                            fs.mkdirSync(taskDataDir, { recursive: true });
                            this._log('RECEIVE','[数据处理流程] taskdata文件夹不存在，已创建');
                        }
                        // 使用异步文件写入
                        await fs.promises.writeFile(savePath, fileData, 'utf-8');
                        this._log('RECEIVE','[数据处理流程] 文件保存成功');
                    } catch (e) {
                        this._log('ERROR','Failed to save the file!', e);
                        return { success: false,
                            message: `文件保存失败: ${e.message}`,
                            savePath: savePath
                        };
                    }
                    const taskIdList = this.getTaskIdListFromXml(fileData.toString('utf8'));
                    // 成功时也要返回结果
                    const result = {
                        success: true,
                        message: '文件处理成功',
                        savePath: savePath,
                        fileName: saveFileName,
                        dataSize: fileData.length,
                        taskIdList: taskIdList
                    };                    
                    // 如果有回调函数，调用回调函数
                    if (this.onDownloadComplete) {
                        this.onDownloadComplete(result);
                    }                    
                    // 使用当前请求的resolve函数
                    if (currentRequest) {
                        this._log('DEBUG', `解析请求成功，包序号: ${this.currentPacketCount}`);
                        const { resolve } = currentRequest;
                        
                        // 检查是否还有更多数据包需要处理（通过查看是否有后续数据的头部标志）
                        if (this.dataBuffer.length >= 4) {
                            const nextHeaderFlag = this.dataBuffer.readUInt32LE(0);
                            if (nextHeaderFlag === this.EXPECTED_FLAG_LE) {
                                // 发现新的头部标志，当前请求处理完成
                                this.currentRequest = null;
                                this.currentPacketCount = 0;
                                resolve(result);                                
                                // 继续处理下一个请求
                                setImmediate(() => {
                                    try {
                                        this._processDataBuffer();
                                    } catch (err) {
                                        this._log('ERROR', `继续处理缓冲区时出错: ${err.message}`);
                                    }
                                });
                            } else {
                                // 没有新的头部标志，继续处理当前请求的下一个数据包
                                resolve(result);
                            }
                        } else {
                            // 缓冲区中没有足够的数据，当前请求处理完成
                            this.currentRequest = null;
                            this.currentPacketCount = 0;
                            resolve(result);
                        }
                    } else {
                        this._log('WARNING', '没有当前请求，无法解析请求结果');
                    }                    
                    return result;
                } catch (e) {
                    this._log('ERROR', `[数据处理流程] 数据处理错误: ${e.message}`);
                    const result = {
                        success: false,
                        message: `tcp文件处理失败: ${e.message}`
                    };                    
                    // 如果有回调函数，调用回调函数
                    if (this.onDownloadComplete) {
                        this.onDownloadComplete(result);
                    }                    
                    // 使用当前请求的reject函数
                    if (currentRequest) {
                        this._log('DEBUG', `解析请求失败，包序号: ${this.currentPacketCount}`);
                        const { reject } = currentRequest;
                        this.currentRequest = null;
                        this.currentPacketCount = 0;
                        reject(result);
                    } else {
                        this._log('WARNING', '没有当前请求，无法拒绝请求');
                    }                    
                    return result;
                }
            } else {
                const rawHeaderHex = handlDataBuffer.slice(0, 4).toString('hex').toUpperCase();
                this._log('WARNING', `头部标志不匹配，期望0xFE6B2840，实际为0x${headerFlag.toString(16).toUpperCase()}，原始字节: ${rawHeaderHex}`);
            }
        } catch (e) {
            this._log('ERROR', `数据解析错误: ${e.message}`);
        }
    }

    async disconnect() {
        if (this.client) {
            this.client.destroy();
            this.client = null;
        }
        this.isConnected = false;
        this.isConnecting = false;
        this.onDataParsed = null;
        this.onDownloadComplete = null;
        this._log('INFO', 'tcp已断开连接');
    }

    getConnectionStatus() {
        return this.isConnected;
    }

    // 构建请求数据包 - 根据协议表格修正为68字节
    buildRequest( cmdType,taskID) {
        // 根据协议表格，总长度应为68字节
        const buf = Buffer.alloc(68);
        let offset = 0;
        const writeUInt32 = buf.writeUInt32LE.bind(buf); // 小端序写入
        const writeUInt16 = buf.writeUInt16LE.bind(buf); // 小端序写入
        const writeBigUInt64 = buf.writeBigUInt64LE.bind(buf); // 小端序写入
        writeUInt32(0xFE6B2840, offset); offset += 4; // headerFlag - 直接使用所需的小端序值
        writeUInt16(0, offset); offset += 2;          // packType
        writeUInt16(4, offset); offset += 2;   // sendType
        writeBigUInt64(BigInt(1), offset); offset += 8; // sendNo (Long类型)
        writeUInt16(1, offset); offset += 2;         // recvType
        writeBigUInt64(BigInt(1), offset); offset += 8; // recvNo (Long类型)
        writeUInt16(cmdType, offset); offset += 2;   // cmdType
        writeBigUInt64(BigInt(1), offset); offset += 8; // replyFlag (Long类型)
        writeBigUInt64(BigInt(taskID), offset); offset += 8; // taskID (Long类型)
        writeBigUInt64(BigInt(0), offset); offset += 8; // reserved3 (Long类型)
        writeBigUInt64(BigInt(0), offset); offset += 8; // md5Flag (Long类型)
        writeBigUInt64(BigInt(0), offset); offset += 8; // dataSize (Long类型)
        this._log(`构建请求数据包完成，总长度: ${buf.length}字节`);
        return buf;
    }

    // 从XML中提取TaskID列表
    getTaskIdListFromXml(xml){
        if (!xml || typeof xml !== 'string') {
            this._log('ERROR', 'getTaskIdListFromXml: 无效的XML数据');
            return [];
        }        
        try {
            const taskIdList = [];
            // 修复正则表达式，使其能够正确匹配各种可能的Task元素格式
            // 允许Task元素有其他属性，属性顺序不固定，属性值可以是任意字符（除引号外）
            const taskRegex = /<Task[^>]*\sTaskID="([^"]+)"/gi;
            let match;            
            while ((match = taskRegex.exec(xml)) !== null) {
                // 提取TaskID值并添加到列表中
                const taskId = match[1];
                if(taskId!=110&&taskId!='110'){
                    taskIdList.push(taskId);
                }else{
                    this._log('INFO', `已从任务列表中忽略任务id为110的任务配置文件`);
                }           
            }            
            this._log('INFO', `从XML中成功提取到${taskIdList.length}个TaskID`);
            return taskIdList;
        } catch (error) {
            this._log('ERROR', `getTaskIdListFromXml: 解析XML失败 - ${error.message}`);
            return [];
        }
    }
     
    send(packet) {
        if (!this.isConnected || !this.client.writable) {
            throw new Error('tcp未连接或连接不可写');
        }
        this.client.write(packet);
        const hex = packet.toString('hex').match(/.{1,2}/g).join(' ');
        this._log('SEND', `数据 (${packet.length} 字节): ${hex}`);
    }
    
    // 添加处理请求的方法，返回Promise
    processRequest(packet) {
        return new Promise((resolve, reject) => {
            // 确保requestQueue已初始化
            if (!this.requestQueue) {
                this.requestQueue = [];
            }
            
            // 将当前请求的resolve和reject函数添加到队列中
            this.requestQueue.push({ resolve, reject });
            
            // 记录请求队列状态
            this._log('DEBUG', `请求已加入队列，当前队列长度: ${this.requestQueue.length}`);
            
            try {
                // 发送请求
                this.send(packet);
            } catch (error) {
                // 发送失败时，从队列中移除请求并reject
                if (this.requestQueue.length > 0) {
                    this.requestQueue.pop(); // 移除刚刚添加的请求
                }
                reject(new Error(`发送请求失败: ${error.message}`));
            }
        });
    }

    // 内部日志方法
    _log(level, message) {
        // 处理message参数，支持可变参数
        if (arguments.length > 2) {
            message = Array.from(arguments).slice(1).join(' ');
        }
        
        const timestamp = new Date().toLocaleTimeString('zh-CN');
        const logMessage = `[${timestamp}] [${level}] ${message}`;

        // 输出到控制台，修复Windows下中文乱码问题
        if (process.platform === 'win32') {
            try {
                // 尝试直接使用utf-8输出到支持utf-8的终端
                console.log(logMessage);
            } catch (e) {
                // 如果失败，尝试使用cp936编码（兼容旧版Windows终端）
                try {
                    const iconv = require('iconv-lite');
                    const encodedMessage = iconv.encode(logMessage, 'cp936');
                    process.stdout.write(encodedMessage + '\n');
                } catch (innerError) {
                    // 双重保险，确保日志能够输出
                    console.log(logMessage);
                }
            }
        } else {
            // 其他平台正常输出
            if (level === 'ERROR') {
                console.error(logMessage);
            } else {
                console.log(logMessage);
            }
        }
        
        // 如果logCallback存在，通过回调函数将日志发送到渲染端控制台
        if (this.logCallback && typeof this.logCallback === 'function') {
            this.logCallback(level, logMessage);
        }
    }
}

module.exports = TcpConfigDownloader;